package com.ruoyi.level.service.impl;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.level.mapper.PointsLevelRuleMapper;
import com.ruoyi.level.domain.PointsLevelRule;
import com.ruoyi.level.service.IPointsLevelRuleService;

/**
 * 用户积分等级规则Service业务层处理
 * 
 * @author 区嘉盛
 * @date 2025-06-16
 */
@Service
public class PointsLevelRuleServiceImpl implements IPointsLevelRuleService 
{
    @Autowired
    private PointsLevelRuleMapper pointsLevelRuleMapper;

    /**
     * 查询用户积分等级规则
     * 
     * @param id 用户积分等级规则主键
     * @return 用户积分等级规则
     */
    @Override
    public PointsLevelRule selectPointsLevelRuleById(Long id)
    {
        return pointsLevelRuleMapper.selectPointsLevelRuleById(id);
    }

    /**
     * 查询用户积分等级规则列表
     * 
     * @param pointsLevelRule 用户积分等级规则
     * @return 用户积分等级规则
     */
    @Override
    public List<PointsLevelRule> selectPointsLevelRuleList(PointsLevelRule pointsLevelRule)
    {
        return pointsLevelRuleMapper.selectPointsLevelRuleList(pointsLevelRule);
    }

    /**
     * 新增用户积分等级规则
     * 
     * @param pointsLevelRule 用户积分等级规则
     * @return 结果
     */
    @Override
    public int insertPointsLevelRule(PointsLevelRule pointsLevelRule)
    {
        return pointsLevelRuleMapper.insertPointsLevelRule(pointsLevelRule);
    }

    /**
     * 修改用户积分等级规则
     * 
     * @param pointsLevelRule 用户积分等级规则
     * @return 结果
     */
    @Override
    public int updatePointsLevelRule(PointsLevelRule pointsLevelRule)
    {
        return pointsLevelRuleMapper.updatePointsLevelRule(pointsLevelRule);
    }

    /**
     * 批量停用用户积分等级规则
     *
     * @param ids 需要停用的用户积分等级规则主键
     * @return 结果
     */
    @Override
    public int disablePointsLevelRuleByIds(Long[] ids)
    {
        return pointsLevelRuleMapper.disablePointsLevelRuleByIds(ids);
    }

    /**
     * 停用用户积分等级规则信息
     *
     * @param id 用户积分等级规则主键
     * @return 结果
     */
    @Override
    public int disablePointsLevelRuleById(Long id)
    {
        return pointsLevelRuleMapper.disablePointsLevelRuleById(id);
    }

    /**
     * 批量启用用户积分等级规则
     *
     * @param ids 需要启用的用户积分等级规则主键
     * @return 结果
     */
    @Override
    public int enablePointsLevelRuleByIds(Long[] ids)
    {
        return pointsLevelRuleMapper.enablePointsLevelRuleByIds(ids);
    }

    /**
     * 启用用户积分等级规则
     *
     * @param id 用户积分等级规则主键
     * @return 结果
     */
    @Override
    public int enablePointsLevelRuleById(Long id)
    {
        return pointsLevelRuleMapper.enablePointsLevelRuleById(id);
    }

    /**
     * 检查指定等级体系下是否存在相同排序号
     * 
     * @param systemName 等级体系名称
     * @param sortOrder 排序号
     * @return 是否存在
     */
    @Override
    public boolean checkSortOrderExists(String systemName, Long sortOrder)
    {
        return pointsLevelRuleMapper.checkSortOrderExists(systemName, sortOrder) > 0;
    }

    /**
     * 检查指定等级体系下是否存在相同等级名称
     * 
     * @param systemName 等级体系名称
     * @param levelName 等级名称
     * @return 是否存在
     */
    @Override
    public boolean checkLevelNameExists(String systemName, String levelName)
    {
        return pointsLevelRuleMapper.checkLevelNameExists(systemName, levelName) > 0;
    }

    /**
     * 检查指定等级体系下是否存在相同排序号（排除指定ID的记录）
     * 
     * @param systemName 等级体系名称
     * @param sortOrder 排序号
     * @param excludeId 要排除的记录ID
     * @return 是否存在
     */
    @Override
    public boolean checkSortOrderExistsExcludeId(String systemName, Long sortOrder, Long excludeId)
    {
        return pointsLevelRuleMapper.checkSortOrderExistsExcludeId(systemName, sortOrder, excludeId) > 0;
    }

    /**
     * 检查指定等级体系下是否存在相同等级名称（排除指定ID的记录）
     * 
     * @param systemName 等级体系名称
     * @param levelName 等级名称
     * @param excludeId 要排除的记录ID
     * @return 是否存在
     */
    @Override
    public boolean checkLevelNameExistsExcludeId(String systemName, String levelName, Long excludeId)
    {
        return pointsLevelRuleMapper.checkLevelNameExistsExcludeId(systemName, levelName, excludeId) > 0;
    }

    // 添加一个常量表示无上限的值
    private static final Long UNLIMITED_POINTS = 2147483647L; // INT最大值表示无上限

    /**
     * 检查是否是最高等级（排序号最大的等级）
     *
     * @param systemName 等级体系名称
     * @param sortOrder 当前等级的排序号
     * @return 是否是最高等级
     */
    @Override
    public boolean isHighestLevel(String systemName, Long sortOrder) {
        // 查询是否有排序号更大的等级
        return pointsLevelRuleMapper.selectHigherLevelRule(systemName, sortOrder) == null;
    }

    /**
     * 检查等级体系中是否已存在无上限的等级
     *
     * @param systemName 等级体系名称
     * @param excludeId 要排除的记录ID（修改时使用）
     * @return 是否存在无上限等级
     */
    @Override
    public boolean hasUnlimitedLevel(String systemName, Long excludeId) {
        return pointsLevelRuleMapper.checkUnlimitedLevelExists(systemName, UNLIMITED_POINTS, excludeId) > 0;
    }

    /**
     * 检查等级规则的积分范围是否符合规则
     * 1. 最低积分不得小于0
     * 2. 最高积分必须大于最低积分
     * 3. 排序号大的等级的最低积分要大于排序号小的等级的最高积分
     * 4. 排序号小的等级的最高积分要小于排序号大的等级的最低积分
     *
     * @param systemName 等级体系名称
     * @param sortOrder 排序号
     * @param minPoints 最低积分
     * @param maxPoints 最高积分
     * @return 校验结果消息，如果为null则表示校验通过
     */
    @Override
    public String checkPointsRangeValid(String systemName, Long sortOrder, Long minPoints, Long maxPoints)
    {
        // 验证最低积分不得小于0
        if (minPoints < 0)
        {
            return "该等级所需最低积分不得小于0";
        }

        // 判断是否是无上限设置
        boolean isUnlimited = UNLIMITED_POINTS.equals(maxPoints);

        // 如果设置为无上限，检查是否是最高等级
        if (isUnlimited && !isHighestLevel(systemName, sortOrder)) {
            return "只有最高等级（排序号最大）才能设置为无上限";
        }

        // 验证最高积分必须大于最低积分
        if (maxPoints <= minPoints)
        {
            return "该等级允许的最高积分必须大于该等级所需最低积分";
        }

        // 检查与下级规则的积分范围
        PointsLevelRule lowerRule = pointsLevelRuleMapper.selectLowerLevelRule(systemName, sortOrder);
        if (lowerRule != null) {
            if (UNLIMITED_POINTS.equals(lowerRule.getMaxPoints())) {
                return "该等级体系已有最高积分为无上限的最高等级";
            }

            if (lowerRule.getMaxPoints() >= minPoints) {
                return "该等级所需最低积分必须大于排序号为" + lowerRule.getSortOrder() + "的等级允许的最高积分" + lowerRule.getMaxPoints();
            }
        }

        // 检查与上级规则的积分范围
        PointsLevelRule higherRule = pointsLevelRuleMapper.selectHigherLevelRule(systemName, sortOrder);
        if (higherRule != null && higherRule.getMinPoints() <= maxPoints)
        {
            return "该等级允许的最高积分必须小于排序号为" + higherRule.getSortOrder() + "的等级所需最低积分" + higherRule.getMinPoints();
        }
        return null;
    }

    /**
     * 获取所有不同的等级体系名称
     *
     * @return 等级体系名称列表
     */
    @Override
    public List<String> selectAllSystemNames()
    {
        return pointsLevelRuleMapper.selectAllSystemNames();
    }
}
